#include<iostream>
#include<vector>
#include"Task.hpp"
#include<cassert>
using namespace std;

const int gnum = 3;//定义一个全局变量
Task t;//任务

class EndPoint
{
public:
    pid_t _child_id;//子进程pid
    int _write_fd;//父进程对管道写端的文件描述符，应该是从下标3开始的
    string processname;//
public:
    EndPoint(int id,int fd)
        :_child_id(id)
         ,_write_fd(fd)
    {

    }
    ~EndPoint()
    {}
};

void WaitCommand()
{
    //子进程从管道中读文件
    while(true)
    {
        int command=0;
        //0号文件描述符，对应的是管道文件pipefd[0]
        //从管道中读取指令，装载到command里
        int n = read(0, &command,sizeof(int));
        if(n == sizeof(int))
        {
            t.Excute(command);
        }
        else if(n == 0)
        {
            cout << "读取完毕，父进程让我退出，我就退出了" << getpid() << endl;
            break;
        }
        else 
        {
            break;
        }
    }
}
void createProcess(vector<EndPoint>* end_points)
{
    for(int i=0;i<gnum;i++)
    {
        //创建管道
        int pipefd[2] = {0};
        int n = pipe(pipefd);
        assert(n==0);
        (void)n;


        //创建进程
        pid_t id=fork();
        assert(id!=-1);
        //子进程
        if(id==0)
        {
            //关闭不要的fd
            close(pipefd[1]);
            dup2(pipefd[0],0);//将标准输入重定向到管道文件
            //子进程开始等待，从管道中获取指令
            WaitCommand();
            close(pipefd[0]);
            exit(0);
        }
        //父进程
        //关闭不要的fd
        close(pipefd[0]);

        //将新的子进程和他的管道写端，构建对象
        end_points->push_back(EndPoint(id,pipefd[1]));
    }
    
}
int main()
{
    vector<EndPoint> end_points;
    //1.先构建控制结构，父进程向管道写入，子进程从管道读取
    createProcess(&end_points);

    //2.构建完后，我们得到了end_points
    ctrlProcess(end_points);

    //3.处理所有的退出问题
    

    return 0;
}
